#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stack>
#include<queue>
using namespace std;
#define maxsize 100
#define maxV 100
typedef struct Enode{
    int adjVex;
    struct Enode *next;
}*en;
typedef struct Vnode{
    char data;
    struct Enode *firstArc;
}*vn,adjList[maxV];
typedef struct agraph{
    int vNum,eNum;
    adjList vertices;
}graph;
void createMg(graph *g){
    int i,j,k;
    printf("请输入顶点数和边数:");
    scanf("%d %d",&g->vNum,&g->eNum);
    printf("请输入顶点信息:");
    for(k=0;k<g->vNum;k++){
        getchar();
        scanf("%c",&g->vertices[k].data);
        g->vertices[k].firstArc=NULL;
    }
    printf("请输入边的信息(<vi,vj>之间有边用i j表示)：");
    for(k=0;k<g->eNum;k++){
        scanf("%d %d",&i,&j);
        en enode=(en)malloc(sizeof(struct Enode));
        enode->adjVex=j;
        enode->next=g->vertices[i].firstArc;//头插法
        g->vertices[i].firstArc=enode;

        // 无向图
        // enode=(en)malloc(sizeof(struct Enode));
        // enode->adjVex=i;
        // enode->next=g->vertices[j].firstArc;
        // g->vertices[j].firstArc=enode;
    }
}
queue<int> Q;
int visited[maxV];
void visit(graph g,int v){
    printf("%c->",g.vertices[v].data);
}
int FirstNeighbor(graph g,int v){
    if(g.vertices[v].firstArc){
        return g.vertices[v].firstArc->adjVex;
    }else{
        return -1;
    }
}
int NextNeighbor(graph g,int w,int v){
    en p=g.vertices[v].firstArc;
    while(p->adjVex!=w){
        p=p->next;
    }
    if(p->next)
        return p->next->adjVex;
    else
        return -1;
}
void bfs(graph g,int v){
    visit(g,v);
    visited[v]=true;
    Q.push(v);
    while(!Q.empty()){
        v=Q.front();
        Q.pop();
        for(int w=FirstNeighbor(g,v);w>=0;w=NextNeighbor(g,w,v)){
            if(!visited[w]){
                visit(g,w);
                visited[w]=true;
                Q.push(w);
            }
        }
    }
    
}
void bfs_traverse(graph g){
    for(int i=0;i<g.vNum;i++){
        visited[i]=false;
    }
    for(int i=0;i<g.vNum;i++){
        if(!visited[i]){
            bfs(g,i);
        }
    }
}
void dfs(graph g,int v){
    visit(g,v);
    visited[v]=true;
    for(int w=FirstNeighbor(g,v);w>=0;w=NextNeighbor(g,w,v)){
        if(!visited[w]){
            dfs(g,w);
        }
    }
}
void dfs_traverse(graph g){
    for(int i=0;i<g.vNum;i++){
        visited[i]=false;
    }
    for(int i=0;i<g.vNum;i++){
        if(!visited[i]){
            dfs(g,i);
        }
    }
}
stack<int> s;
void dfs_iterative(graph g,int v){
    s.push(v);
    while(!s.empty()){
        v=s.top();
        visit(g,v);
        visited[v]=true; 
        s.pop();
        for(int w=FirstNeighbor(g,v);w>=0;w=NextNeighbor(g,w,v)){
            if(!visited[w]){
                s.push(w);
            }
        }
    }
}
void dfs_traverse_iterative(graph g){
    for(int i=0;i<g.vNum;i++){
        visited[i]=false;
    }
    for(int i=0;i<g.vNum;i++){
        if(!visited[i]){
            dfs_iterative(g,i);
        }
    }
}
void printAdjList(graph g){
    en p;
    for(int i=0;i<g.vNum;i++){
        printf("%c->",g.vertices[i].data);
        p=g.vertices[i].firstArc;
        while(p){
            printf("%c->",g.vertices[p->adjVex].data);
            p=p->next;
        }
        printf("\n");
    }
}
void reverseAdjList(graph a,graph *b){
    b->vNum=a.vNum;
    b->eNum=a.eNum;
    for(int i=0;i<b->vNum;i++){
        b->vertices[i].data=a.vertices[i].data;
        b->vertices[i].firstArc=NULL;
    }
    for(int i=0;i<b->eNum;i++){
        en pa=a.vertices[i].firstArc;
        while(pa){
            en enode=(en)malloc(sizeof(struct Enode));
            enode->adjVex=i;
            enode->next=b->vertices[pa->adjVex].firstArc;
            b->vertices[pa->adjVex].firstArc=enode;
            pa=pa->next;
        }
    }
}
void fun(){
    int i,n,flag=1;
    scanf("%d",&n);
    for(i=2;i*i<=n;i++){
        if(n%i==0){
            flag=0;
            break;//非质数，跳出循环
        }
    }
    if(flag){
        printf("%d",n);
    }else{//不是质数
        printf("%d=%d",n,i);
        n=n/i;
        for(int j=2;j<=n;j++){
            while(n%j==0){
                printf("*%d",j);
                n=n/j;
            }
        }
    }
}
void func(int arr[],int n){
    bool visited[maxsize];
    for(int i=0;i<n;i++){
        visited[i]=false;
    }
    for(int i=0;i<n;i++){
        if(!visited[i]){
            visited[i]=true;
            int sum=1;//第一个没有被访问的新元素，初始其数量为1
            for(int j=i+1;j<n;j++){
                if(arr[j]==arr[i]&&!visited[j]){//找和a[i]相同但是没有被访问的元素，数量+1
                    visited[j]=true;
                    sum++;
                }
            }    
            printf("%d出现:%d次\n",arr[i],sum);
        }
        
    }
}
int main(){
    // graph A,B;
    // createMg(&A);
    // printf("\n邻接表为:\n");
    // printAdjList(A);
    // reverseAdjList(A,&B);
    // printf("\n逆邻接表为:\n");
    // printAdjList(B);
    // printf("\nbfs:");
    // bfs_traverse(A);
    // printf("\ndfs递归版:");
    // dfs_traverse(A);
    // printf("\ndfs非递归版:");
    // dfs_traverse_iterative(A);

    // fun();
    // int a[10]={1,2,3,5,4,6,3,4,10,10};
    int arr[10]={1,2,3,4,4,5,5,6,7,7};
    func(arr,10);
    return 0;
}